Python에서 RGB 이미지를 그레이스케일로 변환하려면 어떻게 해야 하나요?

Python에서 RGB 이미지를 그레이스케일로 변환하려면 어떻게 해야 하나요?

사용하려고 합니다.matplotlibRGB 이 rgb rgb rgb rgb rgb rgb rgb rgb rgb rgb rgb 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에서 gray로 변환하는 기능이 내장되어 있지 않다고는 생각되지 않습니다.이미지 처리에서 흔히 볼 수 있는 작업 아닌가요?

Import를 사용하여 할 수 있는 했습니다.imread5월 5일 저는 한 구현이 .그것은 매우 비효율적이지만, 그것이 바로 제가 프로페셔널한 구현을 빌트인하고 싶었던 이유입니다.

세바스찬이 제 기능을 향상시켰지만, 저는 여전히 내장된 기능을 찾고 있습니다.

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('L')
img.save('greyscale.png')

---

에 알파) 가 있는 "Mode " " " " " ( ) " " " 를 합니다.LA:

img = Image.open('image.png').convert('LA')

---

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

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

Ubuntu 16.04 LTS(SSD 탑재 Xeon E5 2670)에서 Python 3.5를 사용하여 1000 RGBA PNG 이미지(224 x 256 픽셀)를 실행하면서 3가지 권장 방법을 테스트했습니다.

평균 실행 시간

pil :1.037초

scipy:1.040초

sk :.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
   

Open(열기)에서 사용하여 이미지 파일을 처음부터 그레이스케일로 읽을 수 있습니다.CV:

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

또한 이미지를 RGB로 읽으려면 약간의 처리를 한 후 Open에서 사용할 수 있는 그레이 스케일로 변환하십시오.CV:

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 색공간에서 YUV/YIQ나 HSL/HSV 등 루마/크로마 모델에 가까운 것으로 인코딩하는 색공간으로 변환한 후 루마 같은 채널을 잘라 그레이스케일 이미지로 사용하는 것이 기본입니다. matplotlib는 YUV/YIQ로 변환하는 메커니즘을 제공하지 않지만 HSV로 변환할 수 있습니다.

사용해보십시오.matplotlib.colors.rgb_to_hsv(img)그런 다음 어레이의 마지막 값(V)을 그레이스케일로 슬라이스합니다.Luma 값과 완전히 동일하지는 않지만, 이것은 당신이 모든 것을 할 수 있다는 것을 의미합니다.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에는 작업을 수행하기 위한 세 가지 알고리즘이 있습니다.

다음 작업을 수행할 수 있습니다.

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

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

NumPy/SciPy를 이미 사용하고 있다면 다음을 사용하는 것이 좋습니다.

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

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

구글을 통해 이미 로딩된 이미지를 그레이스케일로 변환하는 방법을 찾고 있습니다.

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)

OpenCV는 다음과 같이 심플합니다.

import cv2

im = cv2.imread("flower.jpg")

# To Grayscale
im = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
cv2.imwrite("grayscale.jpg", im)

# To Black & White
im = cv2.threshold(im, 127, 255, cv2.THRESH_BINARY)[1]
cv2.imwrite("black-white.jpg", im)

3가지 색 채널(RGB) 전체에서 픽셀의 값이 동일한 경우 해당 픽셀은 항상 그레이스케일 형식입니다.

RGB 이미지를 그레이스케일로 변환하는 심플하고 직관적인 방법 중 하나는 각 픽셀의 모든 컬러 채널의 평균을 구해 해당 픽셀에 값을 다시 할당하는 것입니다.

import numpy as np
from PIL import Image

img=np.array(Image.open('sample.jpg')) #Input - Color image
gray_img=img.copy()

for clr in range(img.shape[2]):
    gray_img[:,:,clr]=img.mean(axis=2) #Take mean of all 3 color channels of each pixel and assign it back to that pixel(in copied image)

#plt.imshow(gray_img) #Result - Grayscale image

이미지 입력:

출력 이미지:

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

사용할 수 있습니다.greyscale()직접 도입할 수 있습니다.

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