Skip to content

Análisis de imágenes con Python: desarrolle una aplicación básica de Photoshop

Este artículo explica sobre el análisis de imágenes con python creando una aplicación básica de Photoshop. La actividad a continuación da una idea clara sobre la lectura de archivos de imagen, su trazado y edición, agregando convoluciones.

La siguiente actividad será un editor de imágenes básico que ayuda a hacer una imagen en blanco y negro, desenfocar, detectar bordes, etc.

¿Qué es una imagen?

La imagen se puede definir como una representación tridimensional de 2/3 que es una visualización de algo.
Ejemplo: tu selfie, radiografía, etc.

La imagen es bidimensional si está en blanco y negro y tridimensional si está coloreada.

La unidad más pequeña de una imagen se llama píxel.

Pocos formatos de imagen famosos incluyen TIFF, JPEG, GIF, PNG, etc.

 ¿Cuáles son los diferentes tipos de imagen?

blackNWhite

Imágenes en blanco y negro

Las imágenes binarias o las imágenes en blanco y negro son cuyos píxeles tienen solo dos colores visibles. Numéricamente, los dos valores visibles son a menudo 0 para negro y 1 o 255 para blanco.

Imágenes en escala de grises

 

La imagen en escala de grises contiene solo tonos de gris y ningún color. Son muy similares a las imágenes en blanco y negro con un tinte de gris en ellas. 

GreyScale
image_3

Imágenes en color

Una imagen en color tiene tres valores (o canales) por píxel. Cada imagen en color está hecha de una combinación de ROJO, VERDE y AZUL.

¡Una imagen en color es 3D a diferencia de B y N y Escala de grises que son 2D! 

 

 ¿Por qué necesitamos análisis de imágenes?

Con un gran revuelo en torno a Computer Vision, la imagen forma la base de cualquier análisis de gráficos o videos. Debemos recordar que los videos no son más que imágenes en movimiento.

Algunas de las aplicaciones de análisis de imágenes de palabras reales incluyen la búsqueda de imágenes de Google, el etiquetado automático de Facebook, etc.

¿Cómo podemos hacer análisis de imágenes?

En términos simples, cada imagen que vemos es una colección de píxeles del backend. Para editar cualquier imagen necesitamos jugar con sus píxeles. Ya sea eliminando algunos o agregando algunos.

Convertimos imágenes en una matriz de valores de píxeles y luego continuamos nuestro viaje de análisis.

pixels

 ¿Cómo ve una computadora una imagen?

 Como vemos, la imagen se interpreta como una matriz donde cada píxel tiene un valor específico. Una vez que la imagen se convierte en números, ¡uf! Sabemos cómo podemos hacer análisis.

what computers see
Antes de que comencemos !
El siguiente programa brindará una descripción general de cómo se puede llevar a cabo un procesamiento de imágenes / análisis.
 
Versión de Pythonnivel de dificultadRequisito previo
2.7+fácilfundamentos de python
Descargue la imagen de entrada de THIS LINK
”’
importar bibliotecas necesarias
si obtiene el error “No se encontró ningún módulo”; Intente instalar usando:
pip install <Nombre del módulo>

”’
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
from scipy.signal import convolve2d
%matplotlib inline
”’
cargar la imagen de 512 * 512 píxeles
”’
pic = mpimg.imread(‘prretty.png’)
#Cómo se ve
plt.imshow(pic)
pic.shape
image_1

Haz una imagen en blanco y negro

”’
Una imagen en color tiene 3 ejes. Solo retenemos 2 aplicando la media en el eje = 2
”’
blackNwhite = img.mean(axis=2)
plt.imshow(blackNwhite, cmap=‘gray’)
image_2

 Vamos a desenfocar una imagen!

”’
crear un filtro gaussiano (GF)
”’
GF = np.zeros((20, 20))
for i in range(20):
for j in range(20):
dist = (i – 9.5)**2 + (j – 9.5)**2 #jugar con valores
GF[i, j] = np.exp(-dist / 50.)
GF /= GF.sum() # normalizar el núcleo

 

#ver la imagen GF
plt.imshow(GF, cmap=‘gray’)
”’
Agreguemos una convolución GF a la imagen en blanco y negro
”’
out = convolve2d(blackNwhite, GF)
plt.imshow(out, cmap=‘gray’)
image_5
”’
vemos que la imagen actual no tiene forma 512 * 512 (a partir de nuestra imagen original)
Después de la convolución, la forma de salida se modificará a N1 + N2 – 1
”’
out.shape
(531, 531)
”’
using mode = ‘same’ mantener intacto el tamaño de la imagen
”’
out = convolve2d(blackNwhite, GF, mode=‘same’)
plt.imshow(out, cmap=‘gray’)
image_5
”’
Desenfocamos la imagen en color
”’
out3 = np.zeros(pic.shape)
print(out3.shape)
for i in range(3):
out3[:,:,i] = convolve2d(img[:,:,i], W, mode=‘same’)
plt.imshow(out3)
image_3

Vamos a detectar bordes!

”’
gradiente aproximado en X dir
Declaramos una matriz con valores estándar # siéntase libre de jugar con números
”’
Hx = np.array([
[-1, 0, 1],
[-2, 0, 2],
[-1, 0, 1],
], dtype=np.float32)

 

Hy = Hx.T
”’
Agreguemos una convolución Hx a la imagen negra y blanca
”’

 

Gx = convolve2d(blackNwhite, Hx)
plt.imshow(Gx, cmap=‘gray’)
blur_1
”’
Agreguemos una convolución Hy a la imagen en blanco y negro
”’

 

Gy = convolve2d(blackNwhite, Hy)
plt.imshow(Gy, cmap=‘gray’)
blur_2

¡Guau, hemos desarrollado un editor de imágenes básico en solo unas pocas líneas de código!

¡Te pueden encantar estas publicaciones recientes!