파이썬에서 RGB 이미지를 그레이 스케일로 어떻게 변환 할 수 있습니까?

파이썬에서 RGB 이미지를 그레이 스케일로 어떻게 변환 할 수 있습니까?

---

내가 사용하려고 해요 matplotlibRGB 이미지에서 읽기 및 그레이 스케일로 변환 할 수 있습니다.

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 분 안에 가져온 이미지로 작동하는 매우 간단한 기능을 작성했습니다 . 끔찍하게 비효율적이지만 전문 구현이 내장되어 있기를 희망하는 이유입니다.

Sebastian은 내 기능을 개선했지만 여전히 내장 기능을 찾고 있습니다.

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-image를 사용 하여 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)

---

제안 된 방법 중 3 가지가 Ubuntu 16.04 LTS (SSD 포함 Xeon E5 2670)에서 Python 3.5로 실행되는 1000 RGBA PNG 이미지 (224 x 256 픽셀)의 속도에 대해 테스트되었습니다.

평균 실행 시간

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로 읽으려면 처리를 한 다음 cvtcolorOpenCV에서 사용할 수있는 그레이 스케일로 변환하십시오 .

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

---

가장 빠르고 현재의 방법은 통해 설치된 Pillow 를 사용하는 것입니다 pip install Pillow.

코드는 다음과 같습니다.

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

---

The tutorial is cheating because it is starting with a greyscale image encoded in RGB, so they are just slicing a single color channel and treating it as greyscale. The basic steps you need to do are to transform from the RGB colorspace to a colorspace that encodes with something approximating the luma/chroma model, such as YUV/YIQ or HSL/HSV, then slice off the luma-like channel and use that as your greyscale image. matplotlib does not appear to provide a mechanism to convert to YUV/YIQ, but it does let you convert to HSV.

Try using matplotlib.colors.rgb_to_hsv(img) then slicing the last value (V) from the array for your grayscale. It's not quite the same as a luma value, but it means you can do it all in matplotlib.

Background:

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

Alternatively, you could use PIL or the builtin colorsys.rgb_to_yiq() to convert to a colorspace with a true luma value. You could also go all in and roll your own luma-only converter, though that's probably overkill.

---

If you're using NumPy/SciPy already you may as well use:

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

---

Using this formula

Y' = 0.299 R + 0.587 G + 0.114 B 

We can do

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

However, the GIMP converting color to grayscale image software has three algorithms to do the task.

---

you could do:

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

---

Use img.Convert(), supports “L”, “RGB” and “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)

Output:

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

---

I came to this question via Google, searching for a way to convert an already loaded image to grayscale.

Here is a way to do it with 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()

You can use greyscale() directly for the transformation.

참고 URL : https://stackoverflow.com/questions/12201577/how-can-i-convert-an-rgb-image-into-grayscale-in-python