Is There Any Good Color Map To Convert Gray-scale Image To Colorful Ones Using Python's Pil?

Matplotlib has a lot of good color maps, but is bad in performance. I'm writing some code to make gray-scale image colorful where interpolate with color map is a good idea. I wonde

Solution 1:

You can use the color maps from matplotlib and apply them without any matplotlib figures etc. This will make things much faster:

import matplotlib.pyplot as plt

# Get the color map by name:
cm = plt.get_cmap('gist_rainbow')

# Apply the colormap like a function to any array:
colored_image = cm(image)

# Obtain a 4-channel image (R,G,B,A) in float [0, 1]# But we want to convert to RGB in uint8 and save it:
Image.fromarray((colored_image[:, :, :3] * 255).astype(np.uint8)).save('test.png')

Note:

• If your input image is float, the values should be in the interval [0.0, 1.0].

• If your input image is integer, the integers should be in the range [0, N) where N is the number of colors in the map. But you can resample the map to any number of values according to you needs:

  # If you need 8 color steps for an integer image with values from 0 to 7:cm = plt.get_cmap('gist_rainbow', lut=8)
  

Solution 2:

I figured out with the duplicate answer mentioned by @ImportanceOfBeingErnest (How to convert Numpy array to PIL image applying matplotlib colormap)

import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import numpy as np

import timeit

from PIL import Image

def pil_test():
    cm_hot = mpl.cm.get_cmap('hot')
    img_src = Image.open('test.jpg').convert('L')
    img_src.thumbnail((512,512))
    im = np.array(img_src)
    im = cm_hot(im)
    im = np.uint8(im * 255)
    im = Image.fromarray(im)
    im.save('test_hot.jpg')

def rgb2gray(rgb):
    return np.dot(rgb[:,:,:3], [0.299, 0.587, 0.114])

def plt_test():
    img_src = mpimg.imread('test.jpg')
    im = rgb2gray(img_src)
    f = plt.figure(figsize=(4, 4), dpi=128)
    plt.axis('off')
    plt.imshow(im, cmap='hot')
    plt.savefig('test2_hot.jpg', dpi=f.dpi)
    plt.close()

t = timeit.timeit(pil_test, number=30)
print('PIL: %s' % t)
t = timeit.timeit(plt_test, number=30)
print('PLT: %s' % t)

The performance result is:

PIL: 1.7473899199976586PLT: 10.632971412000188

They both give me similar result with hot color map.