PIL em Python de fácil a difícil

Para chegar aos algoritmos de processamento complexos, vale a pena analisar esquemas padrão, com os quais sugiro iniciar.

Para exemplos de processamento, uma imagem com diferentes conjuntos de cores será usada:



Para começar, precisamos de dois módulos de biblioteca:

from PIL import Image, ImageDraw 

Configure ferramentas para trabalhos futuros confortáveis:

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

Vamos começar

Processaremos imagens no formato RGB. O PIL também suporta o trabalho com os formatos 1, L, P, RGB, RGBA, CMYK, YCbCr, LAB, HSV, I, F.

Os valores de pixel na imagem são definidos no formato: (x, y), (vermelho, verde, azul) , onde x, y são as coordenadas e os valores numéricos de RGB estão no intervalo de 0 a 255. Ou seja, trabalhamos com uma imagem de 8 bits.

Escala de cinza

Uma tonalidade cinza aparece no caso de igualdade de todas as paletas de cores, portanto, precisamos obter o valor médio aritmético nos três pontos:

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

Inversão

A inversão é obtida subtraindo a cor atual 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)) 

Inversão em escala de cinza

Combinando os dois algoritmos anteriores, você pode escrever o seguinte 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)) 

Inversão seletiva em escala de cinza

Para esse algoritmo, você precisa determinar o valor do limite, que utilizarei 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)) 

Conclusão

Nos artigos a seguir, gostaria de falar sobre como abordar mais localmente a filtragem de imagens, dividindo-a em áreas, além de mostrar possibilidades interessantes do DFS em algoritmos de processamento de imagens