recorrer - ¿Cuál es la forma más rápida de dibujar una imagen a partir de valores de píxeles discretos en Python?

recorrer imagen pixel por pixel python

Question

Deseo dibujar una imagen basada en valores de píxeles calculados, como un medio para visualizar algunos datos. Esencialmente, deseo tomar una matriz bidimensional de trillizos de color y renderizarla.

Tenga en cuenta que esto no es un procesamiento de imagen, ya que no estoy transformando una imagen existente ni haciendo ningún tipo de transformaciones de imagen completa, y tampoco son gráficos vectoriales ya que no hay una estructura predeterminada para la imagen que estoy renderizando- Probablemente esté produciendo manchas amorfas de color, un píxel a la vez.

Necesito renderizar imágenes de 1kx1k píxeles por ahora, pero algo escalable sería útil. El formato objetivo final es PNG o cualquier otro formato sin pérdida.

He estado utilizando PIL en este momento a través de draw.point de ImageDraw, y me estaba preguntando, dadas las características muy específicas y relativamente básicas que necesito, ¿hay alguna biblioteca más rápida disponible?

Answer 1

import Image
im= Image.new(''RGB'', (1024, 1024))
im.putdata([(255,0,0), (0,255,0), (0,0,255)])
im.save(''test.png'')

Coloca un píxel rojo, verde y azul en la esquina superior izquierda de la imagen.

im.fromstring() es aún más rápido si prefieres tratar con valores de bytes.

Answer 2

Si tiene numpy y scipy disponibles (y si está manipulando grandes arreglos en Python, los recomendaría), entonces la función scipy.misc.pilutil.toimage es muy útil. Un simple ejemplo:

import numpy as np
import scipy.misc as smp

# Create a 1024x1024x3 array of 8 bit unsigned integers
data = np.zeros( (1024,1024,3), dtype=np.uint8 )

data[512,512] = [254,0,0]       # Makes the middle pixel red
data[512,513] = [0,0,255]       # Makes the next pixel blue

img = smp.toimage( data )       # Create a PIL image
img.show()                      # View in default viewer

Lo bueno es que la imagen hace frente a los diferentes tipos de datos muy bien, por lo que un conjunto 2D de números en coma flotante se convierte sensiblemente en escala de grises, etc.

Puede descargar numpy y scipy desde http://docs.scipy.org/doc/scipy/reference/misc.html .

Answer 3

Creo que usa PIL para generar un archivo de imagen en el disco, y luego lo carga con un software de lectura de imágenes.

Debería obtener una pequeña mejora de velocidad al representar directamente la imagen en la memoria (ahorrará el costo de escribir la imagen en el disco y luego volver a cargarla). Eche un vistazo a este hilo https://.com/questions/326300/python-best-library-for-drawing para saber cómo renderizar esa imagen con varios módulos de python.

Yo personalmente probaría wxpython y la función dc.DrawBitmap . Si usa dicho módulo en lugar de un lector de imágenes externo, tendrá muchos beneficios:

• velocidad
• podrá crear una interfaz de usuario interactiva con botones para parámetros.
• podrá programar fácilmente una función Zoomin y Zoomout
• podrás trazar la imagen a medida que la computes, lo que puede ser bastante útil si el cálculo lleva mucho tiempo

Answer 4

Requisitos

Para este ejemplo, instale Numpy y Pillow .

Ejemplo

El objetivo es primero representar la imagen que desea crear como una matriz de arreglos de conjuntos de 3 números (RGB); use la array() de Numpy array() , para rendimiento y simplicidad:

import numpy

data = numpy.zeros((1024, 1024, 3), dtype=numpy.uint8)

Ahora, establezca los valores medios RGB de 3 píxeles en rojo, verde y azul:

data[512, 511] = [255, 0, 0]
data[512, 512] = [0, 255, 0]
data[512, 513] = [0, 0, 255]

Luego, use Pillow''s Image.fromarray() para generar una Imagen de la matriz:

from PIL import Image

image = Image.fromarray(data)

Ahora, "muestre" la imagen (en OS X, esto lo abrirá como un archivo temporal en Vista previa):

image.show()

Nota

Esta respuesta fue inspirada por la respuesta de BADCODE, que estaba demasiado desactualizada para usar y demasiado diferente para simplemente actualizar sin reescribir completamente.