Geek asks and answers

Image color change

What is the easiest way to change the color of an entire image using an RGB value? I tried wand, but the documentation did not make much sense to me, and I can only find the change in color intensity in the documentation Pillow.

I tried several solutions on the Internet, but either they did not do what I wanted, or they were outdated but did not work.

I want the whole image to become tinted, and I can control the hue by changing the RGB color, like this:

http://cdn.makeuseof.com/wp-content/uploads/2012/11/Folder-Colorizer-Color-Manager.jpg?69fac7

I can realize the wheel myself, but the changing color part is confusing to me. Hope this will be an easy solution.:)

+1
source share
2 answers

Here is the version of Python 3 code in my other answer . It is almost identical, except for the import, which had to be modified in order to use pillowfork PIL(because only it supports Python 3). Other changes I made were to change statements printinto function calls and where the function is map()used to create a lookup table variable luts.

from PIL import Image
from PIL.ImageColor import getcolor, getrgb
from PIL.ImageOps import grayscale

def image_tint(src, tint='#ffffff'):
    if Image.isStringType(src):  # file path?
        src = Image.open(src)
    if src.mode not in ['RGB', 'RGBA']:
        raise TypeError('Unsupported source image mode: {}'.format(src.mode))
    src.load()

    tr, tg, tb = getrgb(tint)
    tl = getcolor(tint, "L")  # tint color overall luminosity
    if not tl: tl = 1  # avoid division by zero
    tl = float(tl)  # compute luminosity preserving tint factors
    sr, sg, sb = map(lambda tv: tv/tl, (tr, tg, tb))  # per component
                                                      # adjustments
    # create look-up tables to map luminosity to adjusted tint
    # (using floating-point math only to compute table)
    luts = (tuple(map(lambda lr: int(lr*sr + 0.5), range(256))) +
            tuple(map(lambda lg: int(lg*sg + 0.5), range(256))) +
            tuple(map(lambda lb: int(lb*sb + 0.5), range(256))))
    l = grayscale(src)  # 8-bit luminosity version of whole image
    if Image.getmodebands(src.mode) < 4:
        merge_args = (src.mode, (l, l, l))  # for RGB verion of grayscale
    else:  # include copy of src image alpha layer
        a = Image.new("L", src.size)
        a.putdata(src.getdata(3))
        merge_args = (src.mode, (l, l, l, a))  # for RGBA verion of grayscale
        luts += tuple(range(256))  # for 1:1 mapping of copied alpha values

    return Image.merge(*merge_args).point(luts)

if __name__ == '__main__':
    import os
    import sys

    input_image_path = 'Dn3CeZB.png'
    print('tinting "{}"'.format(input_image_path))

    root, ext = os.path.splitext(input_image_path)
    suffix = '_result_py{}'.format(sys.version_info[0])
    result_image_path = root+suffix+ext

    print('creating "{}"'.format(result_image_path))
    result = image_tint(input_image_path, '#383D2D')
    if os.path.exists(result_image_path):  # delete any previous result file
        os.remove(result_image_path)
    result.save(result_image_path)  # file name extension determines format

    print('done')

Here before and after the images. The test image and hue color match what you say you use when you encounter a problem. The results look very similar to the version of Py2, yours, and OK for me ... am I missing something?

screenshot of before and after images

+2
source 
import Image
import numpy as nump

img = Image.open('snapshot.jpg')

# In this case, it a 3-band (red, green, blue) image
# so we'll unpack the bands into 3 separate 2D arrays.
 r, g, b = nump.array(img).T

  # Let make an alpha (transparency) band based on where blue is < 100
  a = nump.zeros_like(b)
  a[b < 100] = 255

 # Random math... This isn't meant to look good...
 # Keep in mind that these are unsigned 8-bit integers, and will overflow.
   # You may want to convert to floats for some calculations.
  r = (b + g) * 5

    # Put things back together and save the result...
  img = Image.fromarray(nump.dstack([item.T for item in (r,g,b,a)]))

   img.save('out.png')

numpy.

. [lnk] (https://pillow.readthedocs.org/)

0

More articles:


All Articles