Como ler o valor RGB de um determinado pixel em Python?

Question

Se eu abrir uma imagem com open("image.jpg"), como posso obter os valores RGB de um pixel supondo que eu tenho as coordenadas do pixel?

Então, como posso fazer o inverso disto? Começando com um gráfico em branco, 'escrever' um pixel com um determinado valor RGB?

Eu preferiria se eu não tenho que baixar qualquer bibliotecas adicionais.

Answer 1

É provavelmente melhor usar o Python biblioteca de imagens para fazer isso que eu estou com medo é um download separado.

A maneira mais fácil de fazer o que você quer é através do href="http://effbot.org/imagingbook/image.htm" método load () no objeto de imagem que retorna um objeto de acesso pixel, que você pode manipular como um array:

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

Como alternativa, olhada ImageDraw que dá uma API muito mais rica para a criação de imagens.

Answer 2

PyPNG - leve PNG decodificador / codificador

Embora as dicas de interrogação no JPG, espero que a minha resposta vai ser útil para algumas pessoas.

Veja como ler e escrever PNG pixels usando PyPNG módulo :

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 é um único módulo Python puro inferior a 4000 linhas, incluindo testes e comentários.

PIL é uma biblioteca de imagens mais abrangente, mas também é significativamente mais pesado.

Answer 3

Usando Pillow (que trabalha com Python 3.x, bem como Python 2.7+), você pode fazer o seguinte:

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

Agora você tem todos os valores de pixel. Se for RGB ou de outro modo pode ser lido por im.mode. Então você pode começar pixels (x, y) por:

pixel_values[width*y+x]

Como alternativa, você pode usar Numpy e remodelar a matriz:

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

Um completo, simples de solução de uso é

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

Answer 4

Como Dave Webb disse:

Aqui está o meu código de trabalho trecho de imprimir as cores de pixel de uma imagem:

import os, sys
import Image

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

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

Answer 5

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

Answer 6

Há um artigo muito bom sobre wiki.wxpython.org direito trabalhar com imagens . O artigo menciona a possibilidade de utilizar wxWindows (wxImage), PIL ou PythonMagick. Pessoalmente, eu usei PIL e wxWidgets e ambos manipulação de imagem make bastante fácil.

Answer 7

Você pode usar pygame 's surfarray módulo. Este módulo tem uma matriz de pixel 3d retornando método chamado pixels3d (superfície). Eu mostrei o uso abaixo:

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

Espero sido útil. Última palavra:. Tela está bloqueada para a vida de screenpix

Answer 8

manipulação de imagens é um tema complexo, e é melhor se você não usar uma biblioteca. Posso recomendar gdmodule que fornece acesso fácil a muitos formatos de imagem diferentes de dentro do Python.

Answer 9

instalar PIL usando o comando "sudo apt-get install python-imaging" e execute o seguinte programa. Ele irá imprimir valores RGB da imagem. Se a imagem é grande redirecionar a saída para um arquivo usando '>' depois abrir o arquivo para ver valores 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]

Answer 10

Você pode usar o módulo Tkinter, que é a interface padrão do Python para o kit de ferramentas Tk GUI e você não precisa de download extra. Consulte https://docs.python.org/2/library/tkinter.html.

(para Python 3, Tkinter é renomeado para tkinter)

Aqui está como configurar os valores 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()

e obter 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(" ")))

Answer 11

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

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

Answer 12

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

Answer 13

Se você estiver olhando para ter três dígitos na forma de um código de cor RGB, o código a seguir deve fazer exatamente isso.

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)

Isso pode funcionar para você.