O redimensionamento de imagens é uma operação fundamental no processamento digital, crucial para adaptar o conteúdo visual a diferentes tamanhos de tela, otimizar armazenamento ou preparar dados para algoritmos de visão computacional. Este artigo explora duas abordagens principais para ajustar as dimensões de uma imagem usando a biblioteca OpenCV: a utilização de funções embutidas de alto nível e a implementação manual de algoritmos básicos de amostragem e interpolação de pixels.

Utilizando a Função cv2.resize() para Redimensionamento

A maneira mais direta e eficiente de redimensionar imagens com OpenCV é através da função cv2.resize(). Esta função oferece flexibilidade para escalar imagens para um tamanho absoluto especificado ou por um fator de escala relativo, e suporta diversos métodos de interpolação.

Para começar, precisamos carregar uma imagem e inspecionar suas dimensões. O atributo .shape de um objeto de imagem NumPy (que é como o OpenCV representa as imagens) fornece a altura, largura e o número de canais de cor.

import cv2

# Carrega a imagem original do disco
caminho_imagem_entrada = 'imagem_exemplo.jpg'
imagem_fonte = cv2.imread(caminho_imagem_entrada, cv2.IMREAD_COLOR)

if imagem_fonte is None:
    print(f"Erro: Não foi possível carregar a imagem em '{caminho_imagem_entrada}'")
else:
    # Obtém as dimensões da imagem de origem
    altura_fonte, largura_fonte, canais_fonte = imagem_fonte.shape
    print(f"Dimensões da imagem de origem: {largura_fonte}x{altura_fonte} pixels, {canais_fonte} canais.")

    # Define as novas dimensões para a imagem de destino (exemplo: reduzir para 50% do tamanho)
    largura_destino = int(largura_fonte * 0.5)
    altura_destino = int(altura_fonte * 0.5)

    # Redimensiona a imagem usando cv2.resize().
    # cv2.INTER_LINEAR é um método de interpolação bilinear, padrão e geralmente uma boa escolha para ampliação.
    # Para redução, cv2.INTER_AREA é frequentemente recomendado para evitar artefatos.
    imagem_resultado = cv2.resize(imagem_fonte, (largura_destino, altura_destino), interpolation=cv2.INTER_LINEAR)

    # Exibe a imagem redimensionada
    cv2.imshow('Imagem Redimensionada com cv2.resize', imagem_resultado)
    print(f"Dimensões da imagem redimensionada: {largura_destino}x{altura_destino} pixels.")

    # Aguarda que uma tecla seja pressionada e depois fecha todas as janelas do OpenCV
    cv2.waitKey(0)
    cv2.destroyAllWindows()

Neste exemplo, a função cv2.resize() recebe a imagem de entrada, o novo tamanho como uma tupla (largura, altura) e um método de interpolação. Os métodos de interpolação definem como os novos valores de pixel são calculados. Para redução, cv2.INTER_AREA é geralmente preferido, enquanto para ampliação, cv2.INTER_LINEAR (bilinear) ou cv2.INTER_CUBIC (bicúbica) oferecem melhores resultados visuais.

Implementação Manual de Redimensionamento

Embora cv2.resize() seja altamente otimizada, entender os princípios subjacentes de como o redimensionamento é feito manualmente é crucial para tarefas que exigem controle fino sobre o processo ou para fins educacionais. A implementação manual envolve o mapeamento de pixels da imagem de destino de volta para a imagem de origem e a determinação de seus valores.

Redução por Amostragem de Pixel

Para reduzir o tamanho de uma imagem, uma abordagem simples é a amostragem direta, onde apenas certos pixels da imagem original são selecionados para compor a nova imagem. Isso é feito calculando a razão de escala e mapeando cada pixel da imagem de destino para um pixel correspondente na imagem de origem.

import cv2
import numpy as np

# Carrega a imagem original
caminho_imagem_entrada = 'imagem_exemplo.jpg'
imagem_fonte = cv2.imread(caminho_imagem_entrada, cv2.IMREAD_COLOR)

if imagem_fonte is None:
    print(f"Erro: Não foi possível carregar a imagem em '{caminho_imagem_entrada}'")
else:
    altura_fonte, largura_fonte, canais_fonte = imagem_fonte.shape

    # Define as dimensões da imagem de destino (ex: metade do tamanho)
    nova_altura = altura_fonte // 2
    nova_largura = largura_fonte // 2

    # Cria uma nova matriz NumPy para a imagem redimensionada, preenchida com zeros
    imagem_amostrada = np.zeros((nova_altura, nova_largura, canais_fonte), dtype=np.uint8)

    # Calcula os fatores de escala para mapear de destino para fonte
    fator_escala_vertical = altura_fonte / nova_altura
    fator_escala_horizontal = largura_fonte / nova_largura

    # Percorre cada pixel da imagem de destino
    for y_destino in range(nova_altura):
        for x_destino in range(nova_largura):
            # Mapeia o pixel de destino de volta para a imagem original
            # Usa int() para pegar o pixel mais próximo (amostragem simples)
            y_fonte = int(y_destino * fator_escala_vertical)
            x_fonte = int(x_destino * fator_escala_horizontal)

            # Atribui o valor do pixel da imagem original para a imagem de destino
            imagem_amostrada[y_destino, x_destino] = imagem_fonte[y_fonte, x_fonte]

    # Exibe a imagem reduzida por amostragem
    cv2.imshow('Imagem Reduzida por Amostragem', imagem_amostrada)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

Esta técnica é eficiente, mas pode introduzir artefatos como o "aliasing" (serrilhamento) ou a perda de detalhes finos, especialmente se o fator de redução for grande. Para mitigar isso, métodos mais sofisticados de interpolação são empregados.

Ampliação por Interpolação de Pixel

Ao ampliar uma imagem, novos pixels precisam ser criados entre os pixels existentes. A interpolação é o processo de estimar os valores desses novos pixels com base nos valores dos pixels vizinhos. Existem vários algoritmos de interpolação, cada um com suas próprias características de desempenho e qualidade visual.

Interpolação por Vizinho Mais Próximo (Nearest Neighbor)

A interpolação por vizinho mais próximo é o método mais simples. Para cada pixel na imagem de destino, ele identifica o pixel correspondente mais próximo na imagem de origem e atribui seu valor. Não são feitos cálculos adicionais.

• Vantagens: Extremamente rápida e computacionalmente barata.
• Desvantagens: Produz imagens com bordas "quadradas" ou serrilhadas (aliasing), especailmente em regiões com transições de cor ou contraste acentuados, resultando em uma qualidade visual inferior para ampliações.

Interpolação Bilinear

A interpolação bilinear é um método mais avançado que produz resultados mais suaves do que o vizinho mais próximo. Em vez de pegar o valor de um único pixel, ela calcula o valor de um novo pixel como uma média ponderada dos quatro pixels vizinhos mais próximos na imagem de origem.

Para cada pixel (x_destino, y_destino) na imagem de destino, ele é mapeado para uma coordenada flutuante (x_fonte, y_fonte) na imagem de origem. Os quatro pixels inteiros mais próximos (x1, y1), (x2, y1), (x1, y2) e (x2, y2) são identificados. O valor do novo pixel é então determinado por uma interpolação linear em duas direções:

1. Primeiro, interpola-se linearmente ao longo do eixo X para os pontos entre (x1, y1) e (x2, y1), e entre (x1, y2) e (x2, y2).
2. Em seguida, interpola-se linearmente ao longo do eixo Y entre os resultados das duas interpolações anteriores.

Este processo pode ser matematicamente expresso como:

P(x, y) = (1-dx)(1-dy)Q11 + (dx)(1-dy)Q21 + (1-dx)(dy)Q12 + (dx)(dy)Q22

Onde Qij são os valores dos pixels vizinhos, e dx e dy são as frações decimais das coordenadas do ponto interpolado em relação ao pixel superior esquerdo (Q11).

• Vantagens: Oferece uma transição de cores mais suave, reduzindo o efeito de serrilhamento e proporcionando uma imagem ampliada com melhor qualidade visual.
• Desvantagens: É mais lenta que a interpolação por vizinho mais próximo devido aos cálculos adicionais. Pode ainda resultar em certa suavização da imagem, perdendo detalhes finos.

Considerações de Mapeamento de Coordenadas

Ao implementar algoritmos de interpolação manualmente, a escolha do sistema de coordenadas é crucial. Uma abordagem comum, e a utilizada por bibliotecas como OpenCV e MATLAB, é alinhar os centros dos pixels da imagem original e da imagem de destino. Isso significa que, ao mapear um pixel (i, j) da imagem de destino para a imagem de origem, a fórmula de transformação de coordenadas deve levar em conta um deslocamento de 0.5 para referenciar o centro do pixel.

Em vez de um mapeamento direto como x_fonte = i * (largura_fonte / nova_largura), é mais preciso usar:

x_fonte = (i + 0.5) * (largura_fonte / nova_largura) - 0.5

E analogamente para y_fonte. Essa correção garante que todos os pixels da imagem original contribuam para a imagem rdeimensionada de forma mais equilibrada, resultando em uma reconstrução de imagem de maior qualidade.