Bagaimana saya bisa mengubah gambar RGB menjadi skala abu-abu dengan Python?

Saya mencoba menggunakan matplotlib untuk membaca dalam gambar RGB dan mengubahnya menjadi skala abu-abu.

Di matlab saya menggunakan ini:

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

Dalam tutorial matplotlib mereka tidak membahasnya. Mereka baru saja membaca gambar

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

dan kemudian mereka mengiris array, tapi itu tidak sama dengan mengubah RGB menjadi grayscale dari apa yang saya mengerti.

lum_img = img[:,:,0]

Saya merasa sulit untuk percaya bahwa numpy atau matplotlib tidak memiliki fungsi bawaan untuk mengkonversi dari rgb ke grey. Bukankah ini operasi yang umum dalam pemrosesan gambar?

Saya menulis fungsi yang sangat sederhana yang berfungsi dengan gambar yang diimpor menggunakan imreaddalam 5 menit. Ini sangat tidak efisien, tapi itu sebabnya saya berharap untuk implementasi profesional built-in.

Sebastian telah meningkatkan fungsi saya, tetapi saya masih berharap untuk menemukan yang built-in.

implementasi 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

Bagaimana kalau melakukannya dengan Bantal :

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

Menggunakan matplotlib dan formula

Y' = 0.2989 R + 0.5870 G + 0.1140 B 

Anda bisa melakukan:

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()

Anda juga dapat menggunakan scikit-image , yang menyediakan beberapa fungsi untuk mengkonversi gambar ndarray, seperti rgb2gray.

from skimage import color
from skimage import io

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

Catatan : Bobot yang digunakan dalam konversi ini dikalibrasi untuk fosfor CRT kontemporer: Y = 0,2125 R + 0,7154 G + 0,0721 B

Atau, Anda dapat membaca gambar dalam skala abu-abu dengan:

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

Tiga dari metode yang disarankan diuji untuk kecepatan dengan 1000 gambar RGBA PNG (224 x 256 piksel) berjalan dengan Python 3.5 pada Ubuntu 16,04 LTS (Xeon E5 2670 dengan SSD).

Waktu lari rata-rata

pil : 1,037 detik

scipy: 1,040 detik

sk : 2,120 detik

PIL dan SciPy memberikan numpyarray yang identik (mulai dari 0 hingga 255). SkImage memberikan array dari 0 hingga 1. Selain itu, warna-warna tersebut dikonversi sedikit berbeda, lihat contoh dari dataset CUB-200.

SkImage:

PIL :

SciPy :

Original:

Diff :

Kode

1. Performa

   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. Keluaran

   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. Perbandingan

   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. Impor

   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. Versi

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

Anda selalu dapat membaca file gambar sebagai skala abu-abu sejak awal menggunakan imreaddari OpenCV:

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

Lebih jauh, jika Anda ingin membaca gambar sebagai RGB, lakukan pemrosesan dan kemudian konversikan ke Skala Abu-abu yang dapat Anda gunakan cvtcolordari OpenCV:

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

Cara tercepat dan saat ini adalah menggunakan Bantal , dipasang melaluipip install Pillow .

Kodenya adalah:

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

Tutorial ini curang karena dimulai dengan gambar skala abu-abu yang dikodekan dalam RGB, sehingga mereka hanya memotong satu saluran warna dan memperlakukannya sebagai skala abu-abu. Langkah-langkah dasar yang perlu Anda lakukan adalah mengubah dari ruang warna RGB ke ruang warna yang mengkodekan dengan sesuatu yang mendekati model luma / chroma, seperti YUV / YIQ atau HSL / HSV, kemudian memotong saluran seperti luma dan menggunakannya sebagai gambar skala abu-abu Anda. matplotlibtampaknya tidak menyediakan mekanisme untuk mengonversi ke YUV / YIQ, tetapi ia memungkinkan Anda mengonversi ke HSV.

Coba gunakan matplotlib.colors.rgb_to_hsv(img)kemudian mengiris nilai terakhir (V) dari array untuk skala abu-abu Anda. Ini tidak sama dengan nilai luma, tetapi itu berarti Anda dapat melakukan semuanyamatplotlib .

Latar Belakang:

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

Atau, Anda bisa menggunakan PIL atau builtin colorsys.rgb_to_yiq()untuk mengonversi ke ruang warna dengan nilai luma yang sebenarnya. Anda juga dapat masuk dan memutar konverter hanya-luma Anda sendiri, meskipun itu mungkin berlebihan.

Menggunakan rumus ini

Y' = 0.299 R + 0.587 G + 0.114 B 

Kita bisa

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'))

Namun, konversi warna GIMP ke perangkat lunak gambar grayscale memiliki tiga algoritma untuk melakukan tugas tersebut.

Jika Anda sudah menggunakan NumPy / SciPy, Anda sebaiknya menggunakan :

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

Anda bisa melakukan:

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()

Gunakan img.Convert (), mendukung "L", "RGB" dan "CMYK." mode

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)

Keluaran:

[[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]]

Saya sampai pada pertanyaan ini melalui Google, mencari cara untuk mengkonversi gambar yang sudah dimuat ke skala abu-abu.

Ini cara untuk melakukannya dengan 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()

Anda dapat menggunakan greyscale()langsung untuk transformasi.