recorrer - procesamiento de imagenes con python pdf

¿Información interactiva de píxeles de una imagen en Python?

Question

Versión corta: ¿existe un método de Python para mostrar una imagen que muestre, en tiempo real, los índices e intensidades de píxeles? ¿De modo que cuando muevo el cursor sobre la imagen, tengo una pantalla continuamente actualizada como pixel[103,214] = 198 (para escala de grises) o pixel[103,214] = (138,24,211) para rgb?

Versión larga:

Supongamos que abro una imagen en escala de grises guardada como ndarray im y la visualizo con imshow desde matplotlib:

im = plt.imread(''image.png'')
plt.imshow(im,cm.gray)

Lo que obtengo es la imagen, y en la parte inferior derecha del marco de la ventana, una visualización interactiva de los índices de píxeles. Excepto que no son del todo, ya que los valores no son enteros: x=134.64 y=129.169 por ejemplo.

Si configuro la pantalla con la resolución correcta:

plt.axis(''equal'')

los valores x e y todavía no son enteros.

El método imshow del paquete spectral hace un mejor trabajo:

import spectral as spc
spc.imshow(im)

Luego, en la parte inferior derecha, ahora tengo pixel=[103,152] por ejemplo.

Sin embargo, ninguno de estos métodos también muestra los valores de píxeles. Entonces tengo dos preguntas:

1. ¿Se puede imshow al imshow de matplotlib (y al imshow de scikit-image ) a mostrar los índices de píxeles correctos (enteros)?
2. ¿Se puede extender cualquiera de estos métodos para mostrar también los valores de píxeles?

Answer 1

Hay un par de formas diferentes de hacerlo.

Puede parchear mono ax.format_coord , similar a este ejemplo oficial . Voy a utilizar un enfoque un poco más "pitónico" aquí que no se basa en variables globales. (Tenga en cuenta que supongo que no se especificó kwarg, como en el ejemplo de matplotlib. Para ser completamente general, debe trabajar un poco más ).

import numpy as np
import matplotlib.pyplot as plt
class Formatter(object):
def __init__(self, im):
self.im = im
def __call__(self, x, y):
z = self.im.get_array()[int(y), int(x)]
return ''x={:.01f}, y={:.01f}, z={:.01f}''.format(x, y, z)
data = np.random.random((10,10))
fig, ax = plt.subplots()
im = ax.imshow(data, interpolation=''none'')
ax.format_coord = Formatter(im)
plt.show()

Alternativamente, solo para conectar uno de mis propios proyectos, puede usar mpldatacursor para esto. Si especifica hover=True , el cuadro aparecerá cuando se desplace sobre un artista habilitado. (De manera predeterminada, solo aparece cuando se hace clic). Tenga en cuenta que mpldatacursor maneja la extent y el origin kwargs para imshow correctamente.

import numpy as np
import matplotlib.pyplot as plt
import mpldatacursor
data = np.random.random((10,10))
fig, ax = plt.subplots()
ax.imshow(data, interpolation=''none'')
mpldatacursor.datacursor(hover=True, bbox=dict(alpha=1, fc=''w''))
plt.show()

Además, olvidé mencionar cómo mostrar los índices de píxeles. En el primer ejemplo, solo se supone que i, j = int(y), int(x) . Puede agregarlos en lugar de x e y , si lo prefiere.

Con mpldatacursor , puede especificarlos con un formateador personalizado. Los argumentos i y j son los índices de píxeles correctos, independientemente de la extent y el origin de la imagen trazada.

Por ejemplo (observe la extent de la imagen frente a las coordenadas i,j mostradas):

import numpy as np
import matplotlib.pyplot as plt
import mpldatacursor
data = np.random.random((10,10))
fig, ax = plt.subplots()
ax.imshow(data, interpolation=''none'', extent=[0, 1.5*np.pi, 0, np.pi])
mpldatacursor.datacursor(hover=True, bbox=dict(alpha=1, fc=''w''),
formatter=''i, j = {i}, {j}/nz = {z:.02g}''.format)
plt.show()

Answer 2

Para obtener información interactiva sobre píxeles de una imagen, use el módulo imagetoolbox. Para descargar el módulo, abra el símbolo del sistema y escriba

pip install imagetoolbox Escriba el código dado para obtener información interactiva de píxeles de una imagen ingrese la descripción de la imagen aquí Salida: ingrese la descripción de la imagen aquí

Answer 3

Todos los ejemplos que he visto solo funcionan si sus extensiones x e y comienzan desde 0. Aquí hay un código que usa las extensiones de su imagen para encontrar el valor z.

import numpy as np
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
d = np.array([[i+j for i in range(-5, 6)] for j in range(-5, 6)])
im = ax.imshow(d)
im.set_extent((-5, 5, -5, 5))
def format_coord(x, y):
"""Format the x and y string display."""
imgs = ax.get_images()
if len(imgs) > 0:
for img in imgs:
try:
array = img.get_array()
extent = img.get_extent()
# Get the x and y index spacing
x_space = np.linspace(extent[0], extent[1], array.shape[1])
y_space = np.linspace(extent[3], extent[2], array.shape[0])
# Find the closest index
x_idx= (np.abs(x_space - x)).argmin()
y_idx= (np.abs(y_space - y)).argmin()
# Grab z
z = array[y_idx, x_idx]
return ''x={:1.4f}, y={:1.4f}, z={:1.4f}''.format(x, y, z)
except (TypeError, ValueError):
pass
return ''x={:1.4f}, y={:1.4f}, z={:1.4f}''.format(x, y, 0)
return ''x={:1.4f}, y={:1.4f}''.format(x, y)
# end format_coord
ax.format_coord = format_coord

Si está utilizando PySide / PyQT, aquí hay un ejemplo para tener una información sobre herramientas de desplazamiento del mouse para los datos

import matplotlib
matplotlib.use("Qt4Agg")
matplotlib.rcParams["backend.qt4"] = "PySide"
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
# Mouse tooltip
from PySide import QtGui, QtCore
mouse_tooltip = QtGui.QLabel()
mouse_tooltip.setFrameShape(QtGui.QFrame.StyledPanel)
mouse_tooltip.setWindowFlags(QtCore.Qt.ToolTip)
mouse_tooltip.setAttribute(QtCore.Qt.WA_TransparentForMouseEvents)
mouse_tooltip.show()
def show_tooltip(msg):
msg = msg.replace('', '', ''/n'')
mouse_tooltip.setText(msg)
pos = QtGui.QCursor.pos()
mouse_tooltip.move(pos.x()+20, pos.y()+15)
mouse_tooltip.adjustSize()
fig.canvas.toolbar.message.connect(show_tooltip)
# Show the plot
plt.show()

Answer 4

Un absoluto "one-liner" para hacer esto: (sin depender de datacursor )

def val_shower(im):
return lambda x,y: ''%dx%d = %d'' % (x,y,im[int(y+.5),int(x+.5)])
plt.imshow(image)
plt.gca().format_coord = val_shower(ims)

Pone la imagen en cierre, así que asegúrese de que si tiene varias imágenes, cada una mostrará sus propios valores.

Answer 5

con Jupyter puedes hacerlo con datacursor(myax) o con ax.format_coord .

Código de muestra:

%matplotlib nbagg
import numpy as np
import matplotlib.pyplot as plt
X = 10*np.random.rand(5,3)
fig,ax = plt.subplots()
myax = ax.imshow(X, cmap=cm.jet,interpolation=''nearest'')
ax.set_title(''hover over the image'')
datacursor(myax)
plt.show()

el datacursor(myax) también se puede reemplazar con ax.format_coord = lambda x,y : "x=%gy=%g" % (x, y)