Comment lire la valeur RVB d'un pixel donné en Python?

Si j'ouvre une image avec open("image.jpg"), comment puis-je obtenir les valeurs RVB d'un pixel en supposant que j'ai les coordonnées du pixel?

Alors, comment puis-je faire l'inverse de ce? En commençant par un blanc graphique, 'écrire' un pixel avec une certaine valeur RVB?

Que je préfère, si je n'avais pas à télécharger des bibliothèques supplémentaires.

InformationsquelleAutor Josh Hunt | 2008-09-26

176

Il est probablement préférable d'utiliser le Python Image De La Bibliothèque de faire ce dont j'ai peur est un téléchargement séparé.

La façon la plus simple de faire ce que vous voulez, c'est via le méthode load() sur l'objet Image qui retourne un pixel de l'accès aux objets, que vous pouvez manipuler comme un tableau:
```
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
```
Sinon, regardez ImageDraw qui donne un effet beaucoup plus riche API pour créer des images.
- Heureusement, l'installation de la LIP est très simple sous Linux et Windows (je ne sais pas sur Mac)
- L'installation de PIL sur Mac m'a pris de manière trop long.
- J'ai installé PIL par pip qui a été assez facile.
- Je l'utilise sur mon Mac (Pypi): easy_install --find-links http://www.pythonware.com/products/pil/ Imaging
- Pour les futurs lecteurs: pip install pillow va installer PIL avec succès et assez rapidement (peut-être besoin sudo si ce n'est dans un virtualenv).
- oreiller.readthedocs.io/en/latest/... affiche les commandes bash sous windows étapes de l'installation. Pas vraiment sûr de savoir comment procéder.
- Cette fois-ci, PIL ne prend pas en charge python 3.x. Donc, l'oreiller est le meilleur choix car il a la même syntaxe. L'installer à l'aide pip install pillow
InformationsquelleAutor Dave Webb

PyPNG - léger PNG encodeur/décodeur

Bien que la question des astuces au JPG, j'espère que ma réponse vous sera utile pour certaines personnes.

Voici comment lire et écrire PNG pixels à l'aide de PyPNG module:

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 est un seul pure module Python moins de 4000 lignes de long, y compris les tests et commentaires.

PIL est plus complète de l'imagerie de la bibliothèque, mais c'est aussi sensiblement plus lourd.

InformationsquelleAutor Constantin

À l'aide de Oreiller (qui fonctionne avec Python 3.X ainsi que Python 2.7+), vous pouvez effectuer les opérations suivantes:

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

Vous disposez maintenant de toutes les valeurs de pixels. Si il est en mode RVB ou un autre mode peut être lu par im.mode. Ensuite, vous pouvez obtenir pixel (x, y) par:

pixel_values[width*y+x]

Alternativement, vous pouvez utiliser Numpy et de remodeler la matrice:

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

Complète, simple à utiliser, la solution est

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

Oreiller soutient python 2.7 sur macosx alors que j'ai seulement trouver python 2.5 sur PIL. Merci!

InformationsquelleAutor Martin Thoma

12

Comme Dave Webb a déclaré:
Voici mon code de travail extrait de l'impression du pixel de couleurs à partir d'une
image:
```
import os, sys
import Image

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

pix = im.load()
print pix[x,y]
```
InformationsquelleAutor Lachlan Phillips

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

InformationsquelleAutor Peter V

3

Il y a un très bon article sur wiki.wxpython.org droit Travailler Avec Des Images. L'article mentionne la possibilité de l'utilisation de wxWidgets (wxImage), PIL ou PythonMagick. Personnellement, j'ai utilisé la LIP et wxWidgets et à la fois faire de la manipulation d'image assez facile.

InformationsquelleAutor Jon Cage

Vous pouvez utiliser pygame's surfarray module. Ce module a une 3d pixel de la matrice de retour de la méthode appelée pixels3d(surface). J'ai montré d'utilisation ci-dessous:

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

Je l'espère, été utile. Dernier mot: l'écran est verrouillé pour la durée de vie de screenpix.

InformationsquelleAutor

2

De manipulation de l'Image est un sujet complexe, et il est préférable si vous ne utiliser une bibliothèque. Je peux recommander gdmodule qui fournit un accès facile à de nombreux différents formats d'image à partir de l'intérieur de Python.
- Quelqu'un sait pourquoi il a été downvoted? Est-il un problème connu avec libgd ou quelque chose? (Je n'avais jamais regardé, mais c'est toujours agréable de savoir qu'il s'agit d'une alternative PiL)
InformationsquelleAutor Greg Hewgill
2

installer PIL à l'aide de la commande "sudo apt-get install python-imaging" et exécutez le programme suivant. Il permet d'imprimer les valeurs RVB de l'image. Si l'image est grande rediriger la sortie vers un fichier en utilisant " >' ensuite, ouvrez le fichier pour voir les valeurs RVB
```
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]
```
InformationsquelleAutor user3423024

Vous pouvez utiliser le module Tkinter, qui est le standard de Python interface pour les Savoirs traditionnels GUI toolkit, et vous n'avez pas besoin de télécharger. Voir https://docs.python.org/2/library/tkinter.html.

(Pour Python 3, Tkinter, est renommé pour tkinter)

Ici est de savoir comment définir les valeurs RVB:

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

Et obtenir RVB:

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

InformationsquelleAutor chenlian

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

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

InformationsquelleAutor user8374199

1
```
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
```
- Alors que ce bout de code peut être la solution, y compris une explication aide vraiment à améliorer la qualité de votre post. Rappelez-vous que vous répondez à la question pour les lecteurs dans l'avenir, et ces personnes pourraient ne pas connaître les raisons de votre code suggestion.
InformationsquelleAutor Idan Rotbart

Si vous êtes à la recherche de trois chiffres dans la forme d'une couleur RVB code, le code suivant devrait le faire.

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)

Cela peut fonctionner pour vous.

InformationsquelleAutor Anupamhayat Shawon

Vous devez vous connecter pour publier un commentaire.