Computação Gráfica: Transformações em Imagens Matriciais

Afluentes: Computação Gráfica

Transformações Geométricas

As transformações geométricas são operações de processamento de imagem para alterar a posição inicial dos seus píxels. Dentre algumas operações, temos ampliação, diminuição, espelhamento, rotação, distorção, etc.. Veremos alguns deles aqui.

Para nossos testes, iremos utilizar a imagem abaixo:

Alteração de Dimensões

Na alteração de dimensões de uma imagem, alteramos as proporções da saída gravando em arquivo contendo a imagem alterada, seja ela ampliada ou reduzida. Na literatura técnica de processamento de imagens existem dois tipos de alterações de dimensões de uma imagem, embora tecnicamente idênticos:

1. scaling a imagem é ampliada ou reduzida por um fator (que pode ser igual para as dimensões horizontal e vertical / preservando a relação de aspecto original / ou não);
2. sizing (ou resizing) é utilizado nos casos em que, ao invés de especificar o fator de ampliação / redução, o usuário especifica o novo tamanho que a imagem deve possuir.

Se quisermos ampliar a imagem, a nova imagem resultante deve possuir o tamanho necessário para comportá-la. A nova imagem irá conter uma quantidade de pixeis maior do que a original. Então, pelo método mais simples, replicamos os pixeis na nova imagem.

Veja que conforme o tamanho da imagem podemos ter um resultado visual onde podemos observar grandes quadriculados referente aos pixeis de origem. Existem algoritmos para suavizar essa percepção.

Abaixo temos um programa em python que faz um scaling em uma imagem alterando a largura e altura para manter o aspecto original.

 1import sys
 2import pygame
 3
 4# Retorna x e y equivalente da imagem original na destino
 5def get_dest_xy(x_orig, y_orig, proportion):
 6    x = int(proportion * x_orig / 100)  # calcula a regra de tres de x
 7    y = int(proportion * y_orig / 100)  # calcula a regra de tres de y
 8    return x, y
 9
10# Retorna x e y equivalente da imagem destino na original
11def get_orig_xy(x_dest, y_dest, proportion):
12    p = 100 / (proportion / 100)    # pega o percentual invertido
13    x = int(p * x_dest / 100)       # calcula a regra de tres de x
14    y = int(p * y_dest / 100)       # calcula a regra de tres de y
15    return x, y
16
17# Redimensiona a imagem
18def resize(image, surface, proportion):
19    # Para cada coluna da imagem de destino
20    for y in range(surface.get_height()):
21        # Para cada linha da imagem de destino
22        for x in range(surface.get_width()):
23            # pega o x e y relativo da imagem original
24            x2, y2 = get_orig_xy(x, y, proportion)
25            # e pinta na imagem de destino
26            surface.set_at((x, y), image.get_at((x2, y2)))
27
28# PROGRAMA PRINCIPAL
29pygame.init()
30
31file_in = sys.argv[1]
32file_out = sys.argv[2]
33proportion = int(sys.argv[3])
34
35image = pygame.image.load(file_in)
36w = image.get_width()
37h = image.get_height()
38sw, sh = get_dest_xy(w, h, proportion)
39
40# cria a surface com a proporção a ser alterada
41surface = pygame.display.set_mode((sw, sh))
42
43# chama a função pra redimensionar
44resize(image, surface, proportion)
45
46# salva a surface como nova imagem
47pygame.image.save(surface, file_out)
48
49pygame.display.set_caption(file_in)
50
51finish = False
52while not finish:
53    for event in pygame.event.get():
54        if event.type == pygame.QUIT:
55            finish = True
56        elif event.type == pygame.KEYDOWN:
57            if event.key == pygame.K_ESCAPE:
58                finish = True
59    pygame.display.update()
60pygame.quit()
61quit()

Exemplo de execução

python3.9 resize.py imagem.jpg out.jpg 120

O exemplo aumenta a imagem em 20% da original (imagem.jpg), criando uma imagem resultado chamada out.jpg.

Exercício

1. Altere o algoritmo para redimensionar apenas a largura e depois apenas a altura. Observe que a imagem irá ficar espichada.

Espelhamento

 1import sys
 2import pygame
 3
 4# Função de espelhamento. O resultado é colocado em surface
 5def flip(image, surface):
 6    w = image.get_width()
 7    h = image.get_height()
 8    for y in range(h):
 9        for x in range(w):
10            # coloca o último pixel na primeira posição,
11            # o penúltimo na segunda, e assim por diante.
12            surface.set_at((w - 1 - x, y), image.get_at((x, y)))
13
14
15# PROGRAMA PRINCIPAL
16pygame.init()
17
18file_in = sys.argv[1]
19file_out = sys.argv[2]
20
21image = pygame.image.load(file_in)
22w = image.get_width()
23h = image.get_height()
24
25# cria a surface com a proporção a ser alterada
26surface = pygame.display.set_mode((w, h))
27
28# chama a função fazer o espelhamento
29flip(image, surface)
30
31# salva a imagem
32pygame.image.save(surface, file_out)
33
34pygame.display.set_caption(file_in)
35
36finish = False
37while not finish:
38    for event in pygame.event.get():
39        if event.type == pygame.QUIT:
40            finish = True
41        elif event.type == pygame.KEYDOWN:
42            if event.key == pygame.K_ESCAPE:
43                finish = True
44    pygame.display.update()
45pygame.quit()
46quit()