Як я можу перетворити RGB-зображення в відтінки сірого в Python?

Я намагаюся використовувати matplotlibдля читання в RGB-зображенні і перетворювати його в масштаб сірого.

У matlab я використовую це:

img = rgb2gray(imread('image.png'));

У підручнику з matplotlib вони не висвітлюються. Вони просто читають на зображенні

import matplotlib.image as mpimg
img = mpimg.imread('image.png')

а потім вони нарізають масив, але це не те саме, що перетворювати RGB у відтінки сірого з того, що я розумію.

lum_img = img[:,:,0]

Мені важко повірити, що numpy або matplotlib не мають вбудованої функції для перетворення з rgb в сіру. Це не звичайна операція з обробки зображень?

Я написав дуже просту функцію, яка працює з імпортованим зображенням за imread5 хвилин. Це жахливо неефективно, але саме тому я сподівався на вбудовану професійну реалізацію.

Себастьян вдосконалив свою функцію, але я все ще сподіваюся знайти вбудований.

реалізація matlab (NTSC / PAL):

import numpy as np

def rgb2gray(rgb):

    r, g, b = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2]
    gray = 0.2989 * r + 0.5870 * g + 0.1140 * b

    return gray

Як щодо цього робити з Подушкою :

from PIL import Image
img = Image.open('image.png').convert('LA')
img.save('greyscale.png')

Використання matplotlib та формули

Y' = 0.2989 R + 0.5870 G + 0.1140 B 

Ви можете зробити:

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

def rgb2gray(rgb):
    return np.dot(rgb[...,:3], [0.2989, 0.5870, 0.1140])

img = mpimg.imread('image.png')     
gray = rgb2gray(img)    
plt.imshow(gray, cmap=plt.get_cmap('gray'), vmin=0, vmax=1)
plt.show()

Ви також можете використовувати scikit-образ , який надає деякі функції для перетворення зображення ndarray, наприклад rgb2gray.

from skimage import color
from skimage import io

img = color.rgb2gray(io.imread('image.png'))

Примітки : Ваги, використані в цьому перетворенні, калібруються для сучасних люмінофорів CRT: Y = 0,2125 R + 0,7154 G + 0,0721 B

Крім того, ви можете прочитати зображення у відтінках сірого:

from skimage import io
img = io.imread('image.png', as_gray=True)

Три запропоновані методи були протестовані на швидкість з 1000 зображеннями RGBA PNG (224 х 256 пікселів), що працюють з Python 3.5 на Ubuntu 16.04 LTS (Xeon E5 2670 з SSD).

Середній час виконання

pil : 1,037 секунди

scipy: 1,040 секунди

sk : 2.120 секунд

PIL і SciPy дали однакові numpyмасиви (від 0 до 255). SkImage надає масиви від 0 до 1. Крім того, кольори перетворюються дещо інші, див. Приклад із набору даних CUB-200.

SkImage:

PIL :

SciPy :

Original:

Diff :

Код

1. Продуктивність

   run_times = dict(sk=list(), pil=list(), scipy=list())
   for t in range(100):
       start_time = time.time()
       for i in range(1000):
           z = random.choice(filenames_png)
           img = skimage.color.rgb2gray(skimage.io.imread(z))
       run_times['sk'].append(time.time() - start_time)
   
   
   start_time = time.time()
   for i in range(1000):
       z = random.choice(filenames_png)
       img = np.array(Image.open(z).convert('L'))
   run_times['pil'].append(time.time() - start_time)
   
   start_time = time.time()
   for i in range(1000):
       z = random.choice(filenames_png)
       img = scipy.ndimage.imread(z, mode='L')
   run_times['scipy'].append(time.time() - start_time)
   
   
   for k, v in run_times.items():
       print('{:5}: {:0.3f} seconds'.format(k, sum(v) / len(v)))

2. Вихідні дані

   z = 'Cardinal_0007_3025810472.jpg'
   img1 = skimage.color.rgb2gray(skimage.io.imread(z)) * 255
   IPython.display.display(PIL.Image.fromarray(img1).convert('RGB'))
   img2 = np.array(Image.open(z).convert('L'))
   IPython.display.display(PIL.Image.fromarray(img2))
   img3 = scipy.ndimage.imread(z, mode='L')
   IPython.display.display(PIL.Image.fromarray(img3))

3. Порівняння

   img_diff = np.ndarray(shape=img1.shape, dtype='float32')
   img_diff.fill(128)
   img_diff += (img1 - img3)
   img_diff -= img_diff.min()
   img_diff *= (255/img_diff.max())
   IPython.display.display(PIL.Image.fromarray(img_diff).convert('RGB'))

4. Імпорт

   import skimage.color
   import skimage.io
   import random
   import time
   from PIL import Image
   import numpy as np
   import scipy.ndimage
   import IPython.display

5. Версії

   skimage.version
   0.13.0
   scipy.version
   0.19.1
   np.version
   1.13.1

Ви завжди можете прочитати файл зображення у вигляді відтінків сірого з самого початку, використовуючи imreadOpenCV:

img = cv2.imread('messi5.jpg', 0)

Крім того, якщо ви хочете прочитати зображення як RGB, виконайте деяку обробку, а потім перетворите на сірий масштаб, який ви можете використовувати cvtcolorз OpenCV:

gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

Найшвидший і поточний спосіб - це використовувати Подушку , встановлену через pip install Pillow.

Код тоді:

from PIL import Image
img = Image.open('input_file.jpg').convert('L')
img.save('output_file.jpg')

Підручник обманює, оскільки він починається із зображення сірого масштабу, закодованого в RGB, тому вони просто нарізають один кольоровий канал і трактують його як сірий масштаб. Основні кроки, які вам потрібно зробити, - це перетворити з простору кольорів RGB в кольоровий простір, що кодує щось, що наближає модель luma / chroma, наприклад, YUV / YIQ або HSL / HSV, а потім відрізати канал, подібний до luma, і використовувати це як ваше зображення відтінків сірого matplotlibне видається, що він забезпечує механізм перетворення в YUV / YIQ, але він дозволяє вам конвертувати в HSV.

Спробуйте використати для matplotlib.colors.rgb_to_hsv(img)того, щоб нарізати останнє значення (V) з масиву для вашої градації сірого. Це не зовсім те саме, що значення луми, але це означає, що ви можете все це зробити matplotlib.

Фон:

• http://matplotlib.sourceforge.net/api/colors_api.html
• http://en.wikipedia.org/wiki/HSL_and_HSV

Крім того, ви можете використовувати PIL або вбудований colorsys.rgb_to_yiq()для перетворення в кольоровий простір з справжнім значенням luma. Ви також можете зайнятись і прокатати свій власний перетворювач, призначений лише для луми, хоча це, мабуть, зайве.

Використовуючи цю формулу

Y' = 0.299 R + 0.587 G + 0.114 B 

Ми можемо зробити

import imageio
import numpy as np
import matplotlib.pyplot as plt

pic = imageio.imread('(image)')
gray = lambda rgb : np.dot(rgb[... , :3] , [0.299 , 0.587, 0.114]) 
gray = gray(pic)  
plt.imshow(gray, cmap = plt.get_cmap(name = 'gray'))

Однак програмне забезпечення для перетворення кольорів GIMP у кольори в градаціях сірого має три алгоритми для виконання завдання.

Якщо ви вже використовуєте NumPy / SciPy, ви також можете використовувати :

scipy.ndimage.imread(file_name, mode='L')

Ви можете зробити:

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

def rgb_to_gray(img):
        grayImage = np.zeros(img.shape)
        R = np.array(img[:, :, 0])
        G = np.array(img[:, :, 1])
        B = np.array(img[:, :, 2])

        R = (R *.299)
        G = (G *.587)
        B = (B *.114)

        Avg = (R+G+B)
        grayImage = img

        for i in range(3):
           grayImage[:,:,i] = Avg

        return grayImage       

image = mpimg.imread("your_image.png")   
grayImage = rgb_to_gray(image)  
plt.imshow(grayImage)
plt.show()

Використовуйте img.Convert (), підтримує "L", "RGB" та "CMYK." режим

import numpy as np
from PIL import Image

img = Image.open("IMG/center_2018_02_03_00_34_32_784.jpg")
img.convert('L')

print np.array(img)

Вихід:

[[135 123 134 ...,  30   3  14]
 [137 130 137 ...,   9  20  13]
 [170 177 183 ...,  14  10 250]
 ..., 
 [112  99  91 ...,  90  88  80]
 [ 95 103 111 ..., 102  85 103]
 [112  96  86 ..., 182 148 114]]

Я прийшов до цього питання через Google, шукаючи спосіб перетворити вже завантажене зображення у відтінки сірого.

Ось спосіб зробити це з SciPy:

import scipy.misc
import scipy.ndimage

# Load an example image
# Use scipy.ndimage.imread(file_name, mode='L') if you have your own
img = scipy.misc.face()

# Convert the image
R = img[:, :, 0]
G = img[:, :, 1]
B = img[:, :, 2]
img_gray = R * 299. / 1000 + G * 587. / 1000 + B * 114. / 1000

# Show the image
scipy.misc.imshow(img_gray)

image=myCamera.getImage().crop(xx,xx,xx,xx).scale(xx,xx).greyscale()

Ви можете використовувати greyscale()безпосередньо для перетворення.