Jak odczytać wartość RGB danego piksela w Pythonie?

Jeśli otworzę obraz za pomocą open("image.jpg"), w jaki sposób mogę uzyskać wartości RGB piksela, zakładając, że mam współrzędne piksela?

W takim razie jak mogę to odwrócić? Zaczynając od pustej grafiki, „napisz” piksel z określoną wartością RGB?

Wolałbym, gdybym nie musiał pobierać żadnych dodatkowych bibliotek.

Prawdopodobnie najlepiej jest użyć do tego biblioteki obrazów Pythona, co niestety jest osobnym pobieraniem.

Najłatwiejszym sposobem na zrobienie tego, co chcesz, jest użycie metody load () w obiekcie Image, która zwraca obiekt dostępu do pikseli, którym możesz manipulować jak tablicą:

from PIL import Image

im = Image.open('dead_parrot.jpg') # Can be many different formats.
pix = im.load()
print im.size  # Get the width and hight of the image for iterating over
print pix[x,y]  # Get the RGBA Value of the a pixel of an image
pix[x,y] = value  # Set the RGBA Value of the image (tuple)
im.save('alive_parrot.png')  # Save the modified pixels as .png

Alternatywnie, spójrz na ImageDraw, który zapewnia znacznie bogatsze API do tworzenia obrazów.

Używając Pillow (który działa z Pythonem 3.X oraz Pythonem 2.7+), możesz wykonać następujące czynności:

from PIL import Image
im = Image.open('image.jpg', 'r')
width, height = im.size
pixel_values = list(im.getdata())

Teraz masz wszystkie wartości pikseli. Jeśli jest to RGB lub inny tryb, można go odczytać im.mode. Następnie możesz uzyskać piksel (x, y)przez:

pixel_values[width*y+x]

Alternatywnie możesz użyć Numpy i zmienić kształt tablicy:

>>> pixel_values = numpy.array(pixel_values).reshape((width, height, 3))
>>> x, y = 0, 1
>>> pixel_values[x][y]
[ 18  18  12]

Kompletne, proste w użyciu rozwiązanie to

# Third party modules
import numpy
from PIL import Image


def get_image(image_path):
    """Get a numpy array of an image so that one can access values[x][y]."""
    image = Image.open(image_path, "r")
    width, height = image.size
    pixel_values = list(image.getdata())
    if image.mode == "RGB":
        channels = 3
    elif image.mode == "L":
        channels = 1
    else:
        print("Unknown mode: %s" % image.mode)
        return None
    pixel_values = numpy.array(pixel_values).reshape((width, height, channels))
    return pixel_values


image = get_image("gradient.png")

print(image[0])
print(image.shape)

Smoke testuje kod

Możesz nie mieć pewności co do kolejności szerokości / wysokości / kanału. Z tego powodu stworzyłem ten gradient:

Obraz ma szerokość 100 pikseli i wysokość 26 pikseli. Ma gradient kolorów od #ffaa00(żółtego) do #ffffff(białego). Wynik to:

[[255 172   5]
 [255 172   5]
 [255 172   5]
 [255 171   5]
 [255 172   5]
 [255 172   5]
 [255 171   5]
 [255 171   5]
 [255 171   5]
 [255 172   5]
 [255 172   5]
 [255 171   5]
 [255 171   5]
 [255 172   5]
 [255 172   5]
 [255 172   5]
 [255 171   5]
 [255 172   5]
 [255 172   5]
 [255 171   5]
 [255 171   5]
 [255 172   4]
 [255 172   5]
 [255 171   5]
 [255 171   5]
 [255 172   5]]
(100, 26, 3)

Kwestie, na które należy zwrócić uwagę:

• Kształt to (szerokość, wysokość, kanały)
• image[0], Stąd pierwszy rząd ma 26 trójek samego koloru

PyPNG - lekki dekoder / koder PNG

Chociaż pytanie wskazuje na JPG, mam nadzieję, że moja odpowiedź będzie przydatna dla niektórych osób.

Oto jak czytać i zapisywać piksele PNG za pomocą modułu PyPNG :

import png, array

point = (2, 10) # coordinates of pixel to be painted red

reader = png.Reader(filename='image.png')
w, h, pixels, metadata = reader.read_flat()
pixel_byte_width = 4 if metadata['alpha'] else 3
pixel_position = point[0] + point[1] * w
new_pixel_value = (255, 0, 0, 0) if metadata['alpha'] else (255, 0, 0)
pixels[
  pixel_position * pixel_byte_width :
  (pixel_position + 1) * pixel_byte_width] = array.array('B', new_pixel_value)

output = open('image-with-red-dot.png', 'wb')
writer = png.Writer(w, h, **metadata)
writer.write_array(output, pixels)
output.close()

PyPNG to pojedynczy, czysty moduł Pythona o długości poniżej 4000 linii, zawierający testy i komentarze.

PIL to obszerniejsza biblioteka obrazowania, ale jest też znacznie cięższa.

Jak powiedział Dave Webb:

Oto mój działający fragment kodu drukujący kolory pikseli z obrazu:

import os, sys
import Image

im = Image.open("image.jpg")
x = 3
y = 4

pix = im.load()
print pix[x,y]

photo = Image.open('IN.jpg') #your image
photo = photo.convert('RGB')

width = photo.size[0] #define W and H
height = photo.size[1]

for y in range(0, height): #each pixel has coordinates
    row = ""
    for x in range(0, width):

        RGB = photo.getpixel((x,y))
        R,G,B = RGB  #now you can use the RGB value

Manipulacja obraz jest złożony temat, i to najlepiej jeśli nie korzystać z biblioteki. Mogę polecić gdmodule, który zapewnia łatwy dostęp do wielu różnych formatów graficznych z poziomu Pythona.

Na wiki.wxpython.org jest naprawdę dobry artykuł zatytułowany Praca z obrazami . Artykuł wspomina o możliwości korzystania z wxWidgets (wxImage), PIL czy PythonMagick. Osobiście użyłem PIL i wxWidgets i oba sprawiają, że manipulowanie obrazami jest dość łatwe.

Możesz użyć modułu surfarray w pygame . Ten moduł ma metodę zwracania tablicy pikseli 3D o nazwie pixels3d (surface). Poniżej pokazałem użycie:

from pygame import surfarray, image, display
import pygame
import numpy #important to import

pygame.init()
image = image.load("myimagefile.jpg") #surface to render
resolution = (image.get_width(),image.get_height())
screen = display.set_mode(resolution) #create space for display
screen.blit(image, (0,0)) #superpose image on screen
display.flip()
surfarray.use_arraytype("numpy") #important!
screenpix = surfarray.pixels3d(image) #pixels in 3d array:
#[x][y][rgb]
for y in range(resolution[1]):
    for x in range(resolution[0]):
        for color in range(3):
            screenpix[x][y][color] += 128
            #reverting colors
screen.blit(surfarray.make_surface(screenpix), (0,0)) #superpose on screen
display.flip() #update display
while 1:
    print finished

Mam nadzieję, że był pomocny. Ostatnie słowo: ekran jest zablokowany na całe życie screenpix.

zainstaluj PIL za pomocą polecenia „sudo apt-get install python-imaging” i uruchom następujący program. Wyświetli wartości RGB obrazu. Jeśli obraz jest duży, przekieruj dane wyjściowe do pliku za pomocą '>', później otwórz plik, aby zobaczyć wartości RGB

import PIL
import Image
FILENAME='fn.gif' #image can be in gif jpeg or png format 
im=Image.open(FILENAME).convert('RGB')
pix=im.load()
w=im.size[0]
h=im.size[1]
for i in range(w):
  for j in range(h):
    print pix[i,j]

Możesz użyć modułu Tkinter, który jest standardowym interfejsem Pythona do zestawu narzędzi Tk GUI i nie potrzebujesz dodatkowego pobierania. Zobacz https://docs.python.org/2/library/tkinter.html .

(W przypadku Pythona 3 nazwa Tkinter została zmieniona na tkinter)

Oto jak ustawić wartości RGB:

#from http://tkinter.unpythonic.net/wiki/PhotoImage
from Tkinter import *

root = Tk()

def pixel(image, pos, color):
    """Place pixel at pos=(x,y) on image, with color=(r,g,b)."""
    r,g,b = color
    x,y = pos
    image.put("#%02x%02x%02x" % (r,g,b), (y, x))

photo = PhotoImage(width=32, height=32)

pixel(photo, (16,16), (255,0,0))  # One lone pixel in the middle...

label = Label(root, image=photo)
label.grid()
root.mainloop()

I zdobądź RGB:

#from http://www.kosbie.net/cmu/spring-14/15-112/handouts/steganographyEncoder.py
def getRGB(image, x, y):
    value = image.get(x, y)
    return tuple(map(int, value.split(" ")))

from PIL import Image
def rgb_of_pixel(img_path, x, y):
    im = Image.open(img_path).convert('RGB')
    r, g, b = im.getpixel((x, y))
    a = (r, g, b)
    return a

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

img=mpimg.imread('Cricket_ACT_official_logo.png')
imgplot = plt.imshow(img)

Jeśli chcesz mieć trzy cyfry w postaci kodu koloru RGB, poniższy kod powinien to zrobić.

i = Image.open(path)
pixels = i.load() # this is not a list, nor is it list()'able
width, height = i.size

all_pixels = []
for x in range(width):
    for y in range(height):
        cpixel = pixels[x, y]
        all_pixels.append(cpixel)

To może działać dla Ciebie.