# Tutorial :RGB Int to RGB - Python

### Question:

How can I convert an RGB integer to the corresponding RGB tuple (R,G,B)? Seems simple enough, but I can't find anything on google.

I know that for every RGB (r,g,b) you have the integer n = r256^2 + g256 + b, how can I solve the reverse in Python, IE given an n, I need the r,g,b values.

### Solution:1

I'm not a Python expert by all means, but as far as I know it has the same operators as C.

If so this should work and it should also be a lot quicker than using modulo and division.

Blue =  RGBint & 255  Green = (RGBint >> 8) & 255  Red =   (RGBint >> 16) & 255

What it does it to mask out the lowest byte in each case (the binary and with 255.. Equals to a 8 one bits). For the green and red component it does the same, but shifts the color-channel into the lowest byte first.

### Solution:2

From a RGB integer:

Blue =  RGBint mod 256  Green = RGBint / 256 mod 256  Red =   RGBint / 256 / 256 mod 256

This can be pretty simply implemented once you know how to get it. :)

Upd: Added python function. Not sure if there's a better way to do it, but this works on Python 3 and 2.4

def rgb_int2tuple(rgbint):      return (rgbint // 256 // 256 % 256, rgbint // 256 % 256, rgbint % 256)

There's also an excellent solution that uses bitshifting and masking that's no doubt much faster that Nils Pipenbrinck posted.

### Solution:3

>>> import struct  >>> str='aabbcc'  >>> struct.unpack('BBB',str.decode('hex'))  (170, 187, 204)    for python3:  >>> struct.unpack('BBB', bytes.fromhex(str))

and

>>> rgb = (50,100,150)  >>> struct.pack('BBB',*rgb).encode('hex')  '326496'    for python3:  >>> bytes.hex(struct.pack('BBB',*rgb))

### Solution:4

I assume you have a 32-bit integer containing the RGB values (e.g. ARGB). Then you can unpack the binary data using the struct module:

# Create an example value (this represents your 32-bit input integer in this example).  # The following line results in exampleRgbValue = binary 0x00FF77F0 (big endian)  exampleRgbValue = struct.pack(">I", 0x00FF77F0)    # Unpack the value (result is: a = 0, r = 255, g = 119, b = 240)  a, r, g, b = struct.unpack("BBBB", exampleRgbValue)

### Solution:5

>>> r, g, b = (111, 121, 131)  >>> packed = int('%02x%02x%02x' % (r, g, b), 16)

This produces the following integer:

>>> packed  7305603

You can then unpack it either the long explicit way:

>>> packed % 256  255  >>> (packed / 256) % 256  131  >>> (packed / 256 / 256) % 256  121  >>> (packed / 256 / 256 / 256) % 256  111

..or in a more compact manner:

>>> b, g, r = [(packed >> (8*i)) & 255 for i in range(3)]  >>> r, g, b

Sample applies with any number of digits, e.g an RGBA colour:

>>> packed = int('%02x%02x%02x%02x' % (111, 121, 131, 141), 16)  >>> [(packed >> (8*i)) & 255 for i in range(4)]  [141, 131, 121, 111]

### Solution:6

Just a note for anyone using Google's Appengine Images Python API. I found I had a situation where I had to supply a method with a 32-bit RGB color value.

Specifically, if you're using the API to convert a PNG (or any image with transparent pixels), you'll need to supply the execute_transforms method with an argument called transparent_substitution_rgb which has to be a 32-bit RGB color value.

Borrowing from dbr's answer, I came up with a method similar to this:

def RGBTo32bitInt(r, g, b):    return int('%02x%02x%02x' % (r, g, b), 16)    transformed_image = image.execute_transforms(output_encoding=images.JPEG, transparent_substitution_rgb=RGBTo32bitInt(255, 127, 0))

### Solution:7

def unpack2rgb(intcol):      tmp, blue= divmod(intcol, 256)      tmp, green= divmod(tmp, 256)      alpha, red= divmod(tmp, 256)      return alpha, red, green, blue

If only the divmod(value, (divider1, divider2, divider3â€¦)) suggestion was accepted, it would have simplified various time conversions too.

### Solution:8

There's probably a shorter way of doing this:

dec=10490586  hex="%06x" % dec  r=hex[:2]  g=hex[2:4]  b=hex[4:6]  rgb=(r,g,b)

EDIT: this is wrong - gives the answer in Hex, OP wanted int. EDIT2: refined to reduce misery and failure - needed '%06x' to ensure hex is always shown as six digits [thanks to Peter Hansen's comment].

### Solution:9

If you are using NumPy and you have an array of RGBints, you can also just change its dtype to extract the red, green, blue and alpha components:

>>> type(rgbints)  numpy.ndarray  >>> rgbints.shape  (1024L, 768L)  >>> rgbints.dtype  dtype('int32')  >>> rgbints.dtype = dtype('4uint8')  >>> rgbints.shape  (1024L, 768L, 4L)  >>> rgbints.dtype  dtype('uint8')

### Solution:10

Adding to what is mentioned above. A concise one-liner alternative.

# 2003199 or #E190FF is Dodger Blue.  tuple((2003199 >> Val) & 255 for Val in (16, 8, 0))  # (30, 144, 255)

And to avoid any confusion in the future.

from collections import namedtuple  RGB = namedtuple('RGB', ('Red', 'Green', 'Blue'))  rgb_integer = 16766720  # Or #ffd700 is Gold.  # The unpacking asterisk prevents a TypeError caused by missing arguments.  RGB(*((rgb_integer >> Val) & 255 for Val in (16, 8, 0)))  # RGB(Red=255, Green=215, Blue=0)

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Previous
Next Post »