MicahElliott/colortrans.py

Used this on a little side hack, thanks!

Hey Paul. NP! This is a fun little conversion. The "color look-up table" should probably be generated instead of enumerated. Anyway, it's a nice little CLI util I've used often for translating.

Thanks for this, I'm using this color table in a javascript script to colorize bash output. Did you type all these colors or is there a source or way to generate the xterm 256 color table?

I'd like to say thanks as well! If I had not stumbled across your gist I probably wouldn't have been able to take my project to the next level. Really appreciated it!

I was able to generate most of the table using Ruby 1.9.2 array method repeated_permutations and a few other tricks.

For a single direction conversion that ignores the grayscale strip and base 16 colours (obviously not optimal, but you can do those two in fast initial passes), you can use a simple colorcube transform given RGB in the range [0, 1]:

round(36 * (r * 5) + 6 * (g * 5) + (b * 5) + 16)

:)

A variant that accepts a hex triplet named rgb:

round(36 * (int(rgb[:2], 16) * 5) + 6 * (int(rgb[2:4], 16) * 5) + (int(rgb[4:], 16) * 5) + 16)

very nice thanks a lot

Thank you for this super handy tool!

This is awesome! I ported it to Ruby to use on a little side project, although I only kept the functionality of hex -> xterm.

I made some very slight modifications to make it work with python3.3. All you have to do is change it to the new print() function.

https://gist.github.com/ifonefox/6046257

Bug: #242424 -> 16, should be 235

262626 returns 0 instead of 235

I admit to being a bit bewildered by the nested loops and complexity in your rgb2short function.

My own attempt (which I wrote before seeing yours) is somewhat briefer:

# Default color levels for the color cube
cubelevels = [0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff]
# Generate a list of midpoints of the above list
snaps = [(x+y)/2 for x, y in zip(cubelevels, [0]+cubelevels)[1:]]

def rgb2short(r, g, b):
    """ Converts RGB values to the nearest equivalent xterm-256 color.
    """
    # Using list of snap points, convert RGB value to cube indexes
    r, g, b = map(lambda x: len(tuple(s for s in snaps if s<x)), (r, g, b))
    # Simple colorcube transform
    return r*36 + g*6 + b + 16

A recommendation for anyone wanting to do this "perfectly": It is preferable to calculate distances in YUV or CIE94 than in RGB.

Distances in the YUV and CIE94 colorspaces more closely match distances in human perception. So using one of those should output colors which appear (to our eyes) to be more similar to the input colors.

YUV is often used for image and video encoding. CIE94 is the more accurate, but YUV is faster/easier to calculate and still a good approximation.

Having said that, when quantizing as coarsely as we are here, doing this will only occasionally produce different results.

I love it, specially the approx. part. cheers mate, you're awesome

Great script thanks for sharing!

See this doc for an explanation of how to convert to/from SGR codes to RGB and how to manipulate RGB and HSV in Bash.
https://github.com/chadj2/bash-ui/blob/master/COLORS.md#xterm-colorspaces

Thanks for writing this, I've included it in a project of mine as a utility script. I've credited you in the README and added an annotation to the script itself. If you'd like me to add credit in a different way or to not include it in my package please let me know.

Thanks for writing this :-)

@TerrorBite, I made your code into a lib + stand alone hybrid. Also, I had to change your snaps definition to move the [1:] outside of the list comprehension. I don't know if that was an actual bug in your code or something wrong with how I used it in Python3. Thanks for your work.

@chadj2, that is an awesome write up. I'm inspired to try to convert the code I have below into pure bash.

#!/usr/bin/env python3

# Default color levels for the color cube
cubelevels = [0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff]
# Generate a list of midpoints of the above list
snaps = [(x+y)/2 for x, y in zip(cubelevels, [0]+cubelevels)][1:]


def rgb2short(r, g, b):
    """ Converts RGB values to the nearest equivalent xterm-256 color."""
    # Using list of snap points, convert RGB value to cube indexes
    r, g, b = map(lambda x: len(tuple(s for s in snaps if s < x)), (r, g, b))
    # Simple colorcube transform
    return r*36 + g*6 + b + 16


def split_into(s, l):
    return [int(s[1][y-l:y], 16) for y in range(l, len(s[1]) + l, l)]


def main():
    """ Pass either 1 hex rgb string or split into 3."""
    import sys
    if len(sys.argv) < 3:
        args = split_into(sys.argv, 2)
    else:
        args = sys.argv
    print(rgb2short(args[0], args[1], args[2]))


if __name__ == '__main__':
    main()

@RichardBronosky I am glad the write up helped. I am seeing you have hundreds of console colors. Consider using a few base colors and allowing the user to adjust them with HSV (explained in the write up).

Harshly saturated colors can be overwhelming for the eyes and washed out or pastel colors can be preferable (e.g. https://ethanschoonover.com/solarized/). The Saturation level allows for adjusting this. Hue would be the base color.

Exactly what I wanted!

Does anyone know how to do the same for 16 color codes?

@TerrorBite, I made your code into a lib + stand alone hybrid. Also, I had to change your snaps definition to move the [1:] outside of the list comprehension. I don't know if that was an actual bug in your code or something wrong with how I used it in Python3. Thanks for your work.

Thanks! So in Python 2, the map() function returns a list, which you can slice. In Python 3, it returns a generator, thus the slice has to be done on the list comprehension after the whole thing is generated.

Thanks for the info! I wonder if exist a pure mathematical formula to get the conversion RGB to the nearest ANSI 256 color code. I would to like implement under C.

@Bedfford https://github.com/craigbarnes/dte/blob/66b9802626b5836c6fed7f65369a4afd41a7b162/src/terminal/color.c#L76-L102

Here's a web UI I made to do this conversion
https://hm66hd.csb.app/

Here's a web UI I made to do this conversion https://hm66hd.csb.app/

Thanks for that, quite helpful!

buggy script, the 256-color conversion is all wrong

Here's a web UI I made to do this conversion https://hm66hd.csb.app/

this is correct converter, but cannot found source code