PIL en Python de fácil a difícil

Para llegar a los complejos algoritmos de procesamiento, vale la pena analizar esquemas estándar, con los cuales sugiero comenzar.

Para procesar ejemplos, se utilizará una imagen con diferentes conjuntos de colores:



Para comenzar, necesitamos dos módulos de biblioteca:

from PIL import Image, ImageDraw 

Configure herramientas para un trabajo futuro cómodo:

 image = Image.open('test.jpg') #   draw = ImageDraw.Draw(image) #     width = image.size[0] #   height = image.size[1] #   pix = image.load() #    

Empecemos

Procesaremos imágenes en formato RGB. PIL también admite trabajar con formatos 1, L, P, RGB, RGBA, CMYK, YCbCr, LAB, HSV, I, F.

Los valores de píxeles en la imagen se establecen en el formato: (x, y), (rojo, verde, azul) , donde x, y son las coordenadas, y los valores numéricos de RGB están en el rango de 0 a 255. Es decir, trabajamos con una imagen de 8 bits.

Escala de grises

Aparece un tinte gris en el caso de igualdad de todas las paletas de colores, por lo que debemos obtener el valor medio aritmético en los tres puntos:

 for x in range(width): for y in range(height): r = pix[x, y][0] #     g = pix[x, y][1] # b = pix[x, y][2] # sr = (r + g + b) // 3 #  draw.point((x, y), (sr, sr, sr)) #  image.save("result.jpg", "JPEG") #    

Inversión

La inversión se obtiene restando el color actual de 255:

 for x in range(width): for y in range(height): r = pix[x, y][0] g = pix[x, y][1] b = pix[x, y][2] draw.point((x, y), (255 - r, 255 - g, 255 - b)) 

Inversión en escala de grises

Combinando los dos algoritmos anteriores, puede escribir el siguiente código:

 for x in range(width): for y in range(height): r = pix[x, y][0] g = pix[x, y][1] b = pix[x, y][2] sr = (r + g + b) // 3 draw.point((x, y), (255 - sr, 255 - sr, 255 - sr)) 

Inversión selectiva en escala de grises

Para este algoritmo, debe determinar el valor umbral, que tomaré para 100:

 for x in range(width): for y in range(height): r = pix[x, y][0] g = pix[x, y][1] b = pix[x, y][2] if (r+g+b)>100: #    100 ,    sr = (r + g + b) // 3 draw.point((x, y), (255-sr, 255-sr, 255-sr)) else: #    sr = (r + g + b) // 3 draw.point((x, y), (sr, sr, sr)) 

Conclusión

En los siguientes artículos, me gustaría hablar sobre cómo enfocar más localmente el filtrado de imágenes dividiéndolo en áreas, así como mostrar posibilidades interesantes de DFS en algoritmos de procesamiento de imágenes